package com.promise.jokerdream.task.step

import kotlinx.coroutines.delay

/**
 * 网络请求步骤接口
 * 每个步骤代表一个独立的网络请求
 */
interface NetworkStep {
    /**
     * 步骤名称
     */
    val stepName: String
    
    /**
     * 步骤描述
     */
    val description: String
    
    /**
     * 是否必需步骤（如果失败是否终止整个任务）
     */
    val isRequired: Boolean
    
    /**
     * 最大重试次数
     */
    val maxRetries: Int
    
    /**
     * 重试间隔（毫秒）
     */
    val retryInterval: Long
    
    /**
     * 执行网络请求步骤
     * @param context 请求上下文，包含之前步骤的结果数据
     * @return 步骤执行结果
     */
    suspend fun execute(context: RequestContext): StepResult
}

/**
 * 请求上下文
 * 用于在步骤之间传递数据
 */
data class RequestContext(
    /**
     * 步骤结果映射，key为步骤名称，value为步骤结果
     */
    val stepResults: MutableMap<String, StepResult> = mutableMapOf(),
    
    /**
     * 共享数据，用于步骤间传递自定义数据
     */
    val sharedData: MutableMap<String, Any> = mutableMapOf(),
    
    /**
     * 当前步骤索引
     */
    var currentStepIndex: Int = 0
) {
    /**
     * 获取指定步骤的结果
     */
    fun getStepResult(stepName: String): StepResult? = stepResults[stepName]
    
    /**
     * 设置步骤结果
     */
    fun setStepResult(stepName: String, result: StepResult) {
        stepResults[stepName] = result
    }
    
    /**
     * 获取共享数据
     */
    @Suppress("UNCHECKED_CAST")
    fun <T> getSharedData(key: String): T? = sharedData[key] as? T
    
    /**
     * 设置共享数据
     */
    fun <T> setSharedData(key: String, value: T) {
        sharedData[key] = value as Any
    }
}

/**
 * 步骤执行结果
 */
sealed class StepResult {
    /**
     * 成功结果
     */
    data class Success(
        val data: String? = null,
        val headers: Map<String, String>? = null,
        val statusCode: Int? = null
    ) : StepResult()
    
    /**
     * 失败结果
     */
    data class Failure(
        val error: Throwable,
        val message: String? = null
    ) : StepResult()
    
    /**
     * 跳过结果（非必需步骤失败时）
     */
    object Skipped : StepResult()
}

/**
 * 基础网络请求步骤
 * 提供通用的网络请求实现
 */
abstract class BaseNetworkStep(
    override val stepName: String,
    override val description: String,
    override val isRequired: Boolean = true,
    override val maxRetries: Int = 3,
    override val retryInterval: Long = 1000L
) : NetworkStep {
    
    /**
     * 执行GET请求
     */
    protected suspend fun get(
        url: String,
        headers: Map<String, String>? = null,
        context: RequestContext
    ): StepResult {
        return executeWithRetry {
            // 这里需要实现具体的GET请求逻辑
            // 暂时返回成功结果
            StepResult.Success(data = "GET response data")
        }
    }
    
    
    /**
     * 带重试的执行
     */
    private suspend fun executeWithRetry(block: suspend () -> StepResult): StepResult {
        var lastError: Throwable? = null
        
        repeat(maxRetries) { attempt ->
            try {
                return block()
            } catch (e: Exception) {
                lastError = e
                if (attempt < maxRetries - 1) {
                    delay(retryInterval)
                }
            }
        }
        
        return StepResult.Failure(
            error = lastError ?: Exception("Unknown error"),
            message = "Failed after $maxRetries attempts"
        )
    }
}
